package com.black.utils.file.compress.jar.entity;

import lombok.Getter;
import lombok.Setter;
import org.objectweb.asm.Type;

import java.util.ArrayList;

/**
 * @author ylx
 */
@Setter
@Getter
public class FieldInfo extends JavaInfo {
    // 字段类型, 若包含泛型则为泛型
    private String type;
    // 字段类型
    private Type fieldType;
    // 字段值
    protected Object value;
    // 泛型类型
    private Type tType;

    public FieldInfo(String name) {
        this(0, name, null, null, null);
    }

    public FieldInfo(int access, String name, String desc, String signature, Object value) {
        // name 为字段名称
        super(name);
        // access 为字段访问权限
        this.access = access;
        // desc 为字段类名全描述
        this.desc = desc;
        // signature 为字段的泛型描述
        this.signature = signature;
        // value 为字段值
        this.value = value;
        // type 为字段类型 若包含泛型则为泛型
        this.type = signature!=null ? signature:desc;
        // fieldType 为字段类型
        this.fieldType = Type.getType(desc);
        // tType 为泛型类型
        // 安全处理复杂泛型签名，避免在复杂情况下崩溃
        this.tType = parseFirstGenericType(signature);
    }

    private Type parseFirstGenericType(String signature) {
        if (signature==null) {
            return null;
        }

        try {
            // 处理带有 <...> 模式的泛型
            int start = signature.indexOf('<');
            int end = signature.lastIndexOf('>');
            if (start!=-1 && end!=-1 && start < end) {
                String typeArgs = signature.substring(start + 1, end);

                // 查找第一个完整类型参数
                for (String typeArg : parseTypeArguments(typeArgs)) {
                    // 跳过类型变量（以T开头）和通配符 (*)
                    if (typeArg.startsWith("T") && typeArg.endsWith(";")) {
                        // 这是类型变量，如 TT;, TE; 等。跳过这些。
                        continue;
                    }
                    if ("*".equals(typeArg)) {
                        // 这是通配符，跳过它
                        continue;
                    }
                    // 尝试解析为Type，但要安全处理
                    try {
                        return Type.getType(typeArg);
                    } catch (Exception e) {
                        // 无法解析为具体类型，继续下一个参数
                    }
                }
            }
        } catch (Exception e) {
            // 如果因任何原因解析失败，返回null而不是崩溃
            System.out.println("警告：无法解析字段 '" + name + "' 的泛型签名: " + signature);
            // 不抛出异常，只返回null
        }
        return null;
    }

    private String[] parseTypeArguments(String typeArgs) {
        // 解析参数如 "TT;TE;" 或 "Ljava/lang/String;I"
        java.util.List<String> args = new ArrayList<>();
        int bracketCount = 0;
        int start = 0;

        for (int i = 0; i < typeArgs.length(); i++) {
            char c = typeArgs.charAt(i);
            if (c=='<') {
                bracketCount++;
            } else if (c=='>') {
                bracketCount--;
            } else if (c==';' && bracketCount==0) {
                // 类型参数的结尾
                String arg = typeArgs.substring(start, i + 1);
                if (!arg.trim().isEmpty()) {
                    args.add(arg.trim());
                }
                start = i + 1;
            }
        }

        // 处理字符串不以';'结尾的情况
        if (start < typeArgs.length()) {
            String remaining = typeArgs.substring(start).trim();
            if (!remaining.isEmpty()) {
                args.add(remaining);
            }
        }
        return args.toArray(new String[0]);
    }
}
